<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<link rel="stylesheet" href="style.css" type="text/css">
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="Start" href="index.html">
<link rel="next" href="Bigarray.Array0.html">
<link rel="Up" href="Bigarray.html">
<link title="Index of types" rel=Appendix href="index_types.html">
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
<link title="Index of values" rel=Appendix href="index_values.html">
<link title="Index of modules" rel=Appendix href="index_modules.html">
<link title="Index of module types" rel=Appendix href="index_module_types.html">
<link title="Arg" rel="Chapter" href="Arg.html">
<link title="Arg_helper" rel="Chapter" href="Arg_helper.html">
<link title="Array" rel="Chapter" href="Array.html">
<link title="ArrayLabels" rel="Chapter" href="ArrayLabels.html">
<link title="Ast_helper" rel="Chapter" href="Ast_helper.html">
<link title="Ast_invariants" rel="Chapter" href="Ast_invariants.html">
<link title="Ast_iterator" rel="Chapter" href="Ast_iterator.html">
<link title="Ast_mapper" rel="Chapter" href="Ast_mapper.html">
<link title="Asttypes" rel="Chapter" href="Asttypes.html">
<link title="Attr_helper" rel="Chapter" href="Attr_helper.html">
<link title="Bigarray" rel="Chapter" href="Bigarray.html">
<link title="Buffer" rel="Chapter" href="Buffer.html">
<link title="Builtin_attributes" rel="Chapter" href="Builtin_attributes.html">
<link title="Bytes" rel="Chapter" href="Bytes.html">
<link title="BytesLabels" rel="Chapter" href="BytesLabels.html">
<link title="Callback" rel="Chapter" href="Callback.html">
<link title="CamlinternalFormat" rel="Chapter" href="CamlinternalFormat.html">
<link title="CamlinternalFormatBasics" rel="Chapter" href="CamlinternalFormatBasics.html">
<link title="CamlinternalLazy" rel="Chapter" href="CamlinternalLazy.html">
<link title="CamlinternalMod" rel="Chapter" href="CamlinternalMod.html">
<link title="CamlinternalOO" rel="Chapter" href="CamlinternalOO.html">
<link title="Ccomp" rel="Chapter" href="Ccomp.html">
<link title="Char" rel="Chapter" href="Char.html">
<link title="Clflags" rel="Chapter" href="Clflags.html">
<link title="Complex" rel="Chapter" href="Complex.html">
<link title="Condition" rel="Chapter" href="Condition.html">
<link title="Config" rel="Chapter" href="Config.html">
<link title="Consistbl" rel="Chapter" href="Consistbl.html">
<link title="Depend" rel="Chapter" href="Depend.html">
<link title="Digest" rel="Chapter" href="Digest.html">
<link title="Docstrings" rel="Chapter" href="Docstrings.html">
<link title="Dynlink" rel="Chapter" href="Dynlink.html">
<link title="Ephemeron" rel="Chapter" href="Ephemeron.html">
<link title="Event" rel="Chapter" href="Event.html">
<link title="Filename" rel="Chapter" href="Filename.html">
<link title="Format" rel="Chapter" href="Format.html">
<link title="Gc" rel="Chapter" href="Gc.html">
<link title="Genlex" rel="Chapter" href="Genlex.html">
<link title="Graphics" rel="Chapter" href="Graphics.html">
<link title="GraphicsX11" rel="Chapter" href="GraphicsX11.html">
<link title="Hashtbl" rel="Chapter" href="Hashtbl.html">
<link title="Identifiable" rel="Chapter" href="Identifiable.html">
<link title="Int32" rel="Chapter" href="Int32.html">
<link title="Int64" rel="Chapter" href="Int64.html">
<link title="Lazy" rel="Chapter" href="Lazy.html">
<link title="Lexer" rel="Chapter" href="Lexer.html">
<link title="Lexing" rel="Chapter" href="Lexing.html">
<link title="List" rel="Chapter" href="List.html">
<link title="ListLabels" rel="Chapter" href="ListLabels.html">
<link title="Location" rel="Chapter" href="Location.html">
<link title="Longident" rel="Chapter" href="Longident.html">
<link title="Map" rel="Chapter" href="Map.html">
<link title="Marshal" rel="Chapter" href="Marshal.html">
<link title="Misc" rel="Chapter" href="Misc.html">
<link title="MoreLabels" rel="Chapter" href="MoreLabels.html">
<link title="Mutex" rel="Chapter" href="Mutex.html">
<link title="Nativeint" rel="Chapter" href="Nativeint.html">
<link title="Numbers" rel="Chapter" href="Numbers.html">
<link title="Obj" rel="Chapter" href="Obj.html">
<link title="Oo" rel="Chapter" href="Oo.html">
<link title="Parse" rel="Chapter" href="Parse.html">
<link title="Parser" rel="Chapter" href="Parser.html">
<link title="Parsetree" rel="Chapter" href="Parsetree.html">
<link title="Parsing" rel="Chapter" href="Parsing.html">
<link title="Pervasives" rel="Chapter" href="Pervasives.html">
<link title="Pparse" rel="Chapter" href="Pparse.html">
<link title="Pprintast" rel="Chapter" href="Pprintast.html">
<link title="Printast" rel="Chapter" href="Printast.html">
<link title="Printexc" rel="Chapter" href="Printexc.html">
<link title="Printf" rel="Chapter" href="Printf.html">
<link title="Profile" rel="Chapter" href="Profile.html">
<link title="Queue" rel="Chapter" href="Queue.html">
<link title="Random" rel="Chapter" href="Random.html">
<link title="Scanf" rel="Chapter" href="Scanf.html">
<link title="Set" rel="Chapter" href="Set.html">
<link title="Simplif" rel="Chapter" href="Simplif.html">
<link title="Sort" rel="Chapter" href="Sort.html">
<link title="Spacetime" rel="Chapter" href="Spacetime.html">
<link title="Stack" rel="Chapter" href="Stack.html">
<link title="StdLabels" rel="Chapter" href="StdLabels.html">
<link title="Str" rel="Chapter" href="Str.html">
<link title="Stream" rel="Chapter" href="Stream.html">
<link title="String" rel="Chapter" href="String.html">
<link title="StringLabels" rel="Chapter" href="StringLabels.html">
<link title="Strongly_connected_components" rel="Chapter" href="Strongly_connected_components.html">
<link title="Syntaxerr" rel="Chapter" href="Syntaxerr.html">
<link title="Sys" rel="Chapter" href="Sys.html">
<link title="Targetint" rel="Chapter" href="Targetint.html">
<link title="Tbl" rel="Chapter" href="Tbl.html">
<link title="Terminfo" rel="Chapter" href="Terminfo.html">
<link title="Thread" rel="Chapter" href="Thread.html">
<link title="ThreadUnix" rel="Chapter" href="ThreadUnix.html">
<link title="Typemod" rel="Chapter" href="Typemod.html">
<link title="Uchar" rel="Chapter" href="Uchar.html">
<link title="Unix" rel="Chapter" href="Unix.html">
<link title="UnixLabels" rel="Chapter" href="UnixLabels.html">
<link title="Warnings" rel="Chapter" href="Warnings.html">
<link title="Weak" rel="Chapter" href="Weak.html"><title>Bigarray.Genarray</title>
</head>
<body>
<div class="navbar">&nbsp;<a class="up" href="Bigarray.html" title="Bigarray">Up</a>
&nbsp;<a class="post" href="Bigarray.Array0.html" title="Bigarray.Array0">Next</a>
</div>
<h1>Module <a href="type_Bigarray.Genarray.html">Bigarray.Genarray</a></h1>

<pre><span id="MODULEGenarray"><span class="keyword">module</span> Genarray</span>: <code class="code"><span class="keyword">sig</span></code> <a href="Bigarray.Genarray.html">..</a> <code class="code"><span class="keyword">end</span></code></pre><hr width="100%">

<pre><span id="TYPEt"><span class="keyword">type</span> <code class="type">('a, 'b, 'c)</code> t</span> = <code class="type">('a, 'b, 'c) CamlinternalBigarray.genarray</code> </pre>
<div class="info ">
<div class="info-desc">
<p>The type <code class="code"><span class="constructor">Genarray</span>.t</code> is the type of big arrays with variable
     numbers of dimensions.  Any number of dimensions between 0 and 16
     is supported.</p>

<p>The three type parameters to <code class="code"><span class="constructor">Genarray</span>.t</code> identify the array element
     kind and layout, as follows:</p>
<ul>
<li>the first parameter, <code class="code"><span class="keywordsign">'</span>a</code>, is the OCaml type for accessing array
       elements (<code class="code">float</code>, <code class="code">int</code>, <code class="code">int32</code>, <code class="code">int64</code>, <code class="code">nativeint</code>);</li>
<li>the second parameter, <code class="code"><span class="keywordsign">'</span>b</code>, is the actual kind of array elements
       (<code class="code">float32_elt</code>, <code class="code">float64_elt</code>, <code class="code">int8_signed_elt</code>, <code class="code">int8_unsigned_elt</code>,
       etc);</li>
<li>the third parameter, <code class="code"><span class="keywordsign">'</span>c</code>, identifies the array layout
       (<code class="code">c_layout</code> or <code class="code">fortran_layout</code>).</li>
</ul>
<p>For instance, <code class="code">(float,&nbsp;float32_elt,&nbsp;fortran_layout)&nbsp;<span class="constructor">Genarray</span>.t</code>
     is the type of generic big arrays containing 32-bit floats
     in Fortran layout; reads and writes in this array use the
     OCaml type <code class="code">float</code>.</p>
</div>
</div>


<pre><span id="VALcreate"><span class="keyword">val</span> create</span> : <code class="type">('a, 'b) <a href="Bigarray.html#TYPEkind">Bigarray.kind</a> -><br>       'c <a href="Bigarray.html#TYPElayout">Bigarray.layout</a> -> int array -> ('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a></code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">Genarray</span>.create&nbsp;kind&nbsp;layout&nbsp;dimensions</code> returns a new big array
     whose element kind is determined by the parameter <code class="code">kind</code> (one of
     <code class="code">float32</code>, <code class="code">float64</code>, <code class="code">int8_signed</code>, etc) and whose layout is
     determined by the parameter <code class="code">layout</code> (one of <code class="code">c_layout</code> or
     <code class="code">fortran_layout</code>).  The <code class="code">dimensions</code> parameter is an array of
     integers that indicate the size of the big array in each dimension.
     The length of <code class="code">dimensions</code> determines the number of dimensions
     of the bigarray.</p>

<p>For instance, <code class="code"><span class="constructor">Genarray</span>.create&nbsp;int32&nbsp;c_layout&nbsp;[|4;6;8|]</code>
     returns a fresh big array of 32-bit integers, in C layout,
     having three dimensions, the three dimensions being 4, 6 and 8
     respectively.</p>

<p>Big arrays returned by <code class="code"><span class="constructor">Genarray</span>.create</code> are not initialized:
     the initial values of array elements is unspecified.</p>

<p><code class="code"><span class="constructor">Genarray</span>.create</code> raises <code class="code"><span class="constructor">Invalid_argument</span></code> if the number of dimensions
     is not in the range 0 to 16 inclusive, or if one of the dimensions
     is negative.</p>
</div>
</div>

<pre><span id="VALnum_dims"><span class="keyword">val</span> num_dims</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> int</code></pre><div class="info ">
<div class="info-desc">
<p>Return the number of dimensions of the given big array.</p>
</div>
</div>

<pre><span id="VALdims"><span class="keyword">val</span> dims</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> int array</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">Genarray</span>.dims&nbsp;a</code> returns all dimensions of the big array <code class="code">a</code>,
     as an array of integers of length <code class="code"><span class="constructor">Genarray</span>.num_dims&nbsp;a</code>.</p>
</div>
</div>

<pre><span id="VALnth_dim"><span class="keyword">val</span> nth_dim</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> int -> int</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">Genarray</span>.nth_dim&nbsp;a&nbsp;n</code> returns the <code class="code">n</code>-th dimension of the
     big array <code class="code">a</code>.  The first dimension corresponds to <code class="code">n&nbsp;=&nbsp;0</code>;
     the second dimension corresponds to <code class="code">n&nbsp;=&nbsp;1</code>; the last dimension,
     to <code class="code">n&nbsp;=&nbsp;<span class="constructor">Genarray</span>.num_dims&nbsp;a&nbsp;-&nbsp;1</code>.
     Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">n</code> is less than 0 or greater or equal than
     <code class="code"><span class="constructor">Genarray</span>.num_dims&nbsp;a</code>.</p>
</div>
</div>

<pre><span id="VALkind"><span class="keyword">val</span> kind</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> ('a, 'b) <a href="Bigarray.html#TYPEkind">Bigarray.kind</a></code></pre><div class="info ">
<div class="info-desc">
<p>Return the kind of the given big array.</p>
</div>
</div>

<pre><span id="VALlayout"><span class="keyword">val</span> layout</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> 'c <a href="Bigarray.html#TYPElayout">Bigarray.layout</a></code></pre><div class="info ">
<div class="info-desc">
<p>Return the layout of the given big array.</p>
</div>
</div>

<pre><span id="VALchange_layout"><span class="keyword">val</span> change_layout</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -><br>       'd <a href="Bigarray.html#TYPElayout">Bigarray.layout</a> -> ('a, 'b, 'd) <a href="Bigarray.Genarray.html#TYPEt">t</a></code></pre><div class="info ">
<div class="info-desc">
<p><code class="code"><span class="constructor">Genarray</span>.change_layout&nbsp;a&nbsp;layout</code> returns a bigarray with the
      specified <code class="code">layout</code>, sharing the data with <code class="code">a</code> (and hence having
      the same dimensions as <code class="code">a</code>). No copying of elements is involved: the
      new array and the original array share the same storage space.
      The dimensions are reversed, such that <code class="code">get&nbsp;v&nbsp;[|&nbsp;a;&nbsp;b&nbsp;|]</code> in
      C layout becomes <code class="code">get&nbsp;v&nbsp;[|&nbsp;b+1;&nbsp;a+1&nbsp;|]</code> in Fortran layout.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.04.0</li>
</ul>
</div>

<pre><span id="VALsize_in_bytes"><span class="keyword">val</span> size_in_bytes</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> int</code></pre><div class="info ">
<div class="info-desc">
<p><code class="code">size_in_bytes&nbsp;a</code> is the number of elements in <code class="code">a</code> multiplied
    by <code class="code">a</code>'s <a href="Bigarray.html#VALkind_size_in_bytes"><code class="code"><span class="constructor">Bigarray</span>.kind_size_in_bytes</code></a>.</p>
</div>
<ul class="info-attributes">
<li><b>Since</b> 4.03.0</li>
</ul>
</div>

<pre><span id="VALget"><span class="keyword">val</span> get</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> int array -> 'a</code></pre><div class="info ">
<div class="info-desc">
<p>Read an element of a generic big array.
     <code class="code"><span class="constructor">Genarray</span>.get&nbsp;a&nbsp;[|i1;&nbsp;...;&nbsp;iN|]</code> returns the element of <code class="code">a</code>
     whose coordinates are <code class="code">i1</code> in the first dimension, <code class="code">i2</code> in
     the second dimension, ..., <code class="code">iN</code> in the <code class="code"><span class="constructor">N</span></code>-th dimension.</p>

<p>If <code class="code">a</code> has C layout, the coordinates must be greater or equal than 0
     and strictly less than the corresponding dimensions of <code class="code">a</code>.
     If <code class="code">a</code> has Fortran layout, the coordinates must be greater or equal
     than 1 and less or equal than the corresponding dimensions of <code class="code">a</code>.
     Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if the array <code class="code">a</code> does not have exactly <code class="code"><span class="constructor">N</span></code>
     dimensions, or if the coordinates are outside the array bounds.</p>

<p>If <code class="code"><span class="constructor">N</span>&nbsp;&gt;&nbsp;3</code>, alternate syntax is provided: you can write
     <code class="code">a.{i1,&nbsp;i2,&nbsp;...,&nbsp;iN}</code> instead of <code class="code"><span class="constructor">Genarray</span>.get&nbsp;a&nbsp;[|i1;&nbsp;...;&nbsp;iN|]</code>.
     (The syntax <code class="code">a.{...}</code> with one, two or three coordinates is
     reserved for accessing one-, two- and three-dimensional arrays
     as described below.)</p>
</div>
</div>

<pre><span id="VALset"><span class="keyword">val</span> set</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> int array -> 'a -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Assign an element of a generic big array.
     <code class="code"><span class="constructor">Genarray</span>.set&nbsp;a&nbsp;[|i1;&nbsp;...;&nbsp;iN|]&nbsp;v</code> stores the value <code class="code">v</code> in the
     element of <code class="code">a</code> whose coordinates are <code class="code">i1</code> in the first dimension,
     <code class="code">i2</code> in the second dimension, ..., <code class="code">iN</code> in the <code class="code"><span class="constructor">N</span></code>-th dimension.</p>

<p>The array <code class="code">a</code> must have exactly <code class="code"><span class="constructor">N</span></code> dimensions, and all coordinates
     must lie inside the array bounds, as described for <code class="code"><span class="constructor">Genarray</span>.get</code>;
     otherwise, <code class="code"><span class="constructor">Invalid_argument</span></code> is raised.</p>

<p>If <code class="code"><span class="constructor">N</span>&nbsp;&gt;&nbsp;3</code>, alternate syntax is provided: you can write
     <code class="code">a.{i1,&nbsp;i2,&nbsp;...,&nbsp;iN}&nbsp;&lt;-&nbsp;v</code> instead of
     <code class="code"><span class="constructor">Genarray</span>.set&nbsp;a&nbsp;[|i1;&nbsp;...;&nbsp;iN|]&nbsp;v</code>.
     (The syntax <code class="code">a.{...}&nbsp;&lt;-&nbsp;v</code> with one, two or three coordinates is
     reserved for updating one-, two- and three-dimensional arrays
     as described below.)</p>
</div>
</div>

<pre><span id="VALsub_left"><span class="keyword">val</span> sub_left</span> : <code class="type">('a, 'b, <a href="Bigarray.html#TYPEc_layout">Bigarray.c_layout</a>) <a href="Bigarray.Genarray.html#TYPEt">t</a> -><br>       int -> int -> ('a, 'b, <a href="Bigarray.html#TYPEc_layout">Bigarray.c_layout</a>) <a href="Bigarray.Genarray.html#TYPEt">t</a></code></pre><div class="info ">
<div class="info-desc">
<p>Extract a sub-array of the given big array by restricting the
     first (left-most) dimension.  <code class="code"><span class="constructor">Genarray</span>.sub_left&nbsp;a&nbsp;ofs&nbsp;len</code>
     returns a big array with the same number of dimensions as <code class="code">a</code>,
     and the same dimensions as <code class="code">a</code>, except the first dimension,
     which corresponds to the interval <code class="code">[ofs&nbsp;...&nbsp;ofs&nbsp;+&nbsp;len&nbsp;-&nbsp;1]</code>
     of the first dimension of <code class="code">a</code>.  No copying of elements is
     involved: the sub-array and the original array share the same
     storage space.  In other terms, the element at coordinates
     <code class="code">[|i1;&nbsp;...;&nbsp;iN|]</code> of the sub-array is identical to the
     element at coordinates <code class="code">[|i1+ofs;&nbsp;...;&nbsp;iN|]</code> of the original
     array <code class="code">a</code>.</p>

<p><code class="code"><span class="constructor">Genarray</span>.sub_left</code> applies only to big arrays in C layout.
     Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">ofs</code> and <code class="code">len</code> do not designate
     a valid sub-array of <code class="code">a</code>, that is, if <code class="code">ofs&nbsp;&lt;&nbsp;0</code>, or <code class="code">len&nbsp;&lt;&nbsp;0</code>,
     or <code class="code">ofs&nbsp;+&nbsp;len&nbsp;&gt;&nbsp;<span class="constructor">Genarray</span>.nth_dim&nbsp;a&nbsp;0</code>.</p>
</div>
</div>

<pre><span id="VALsub_right"><span class="keyword">val</span> sub_right</span> : <code class="type">('a, 'b, <a href="Bigarray.html#TYPEfortran_layout">Bigarray.fortran_layout</a>) <a href="Bigarray.Genarray.html#TYPEt">t</a> -><br>       int -> int -> ('a, 'b, <a href="Bigarray.html#TYPEfortran_layout">Bigarray.fortran_layout</a>) <a href="Bigarray.Genarray.html#TYPEt">t</a></code></pre><div class="info ">
<div class="info-desc">
<p>Extract a sub-array of the given big array by restricting the
     last (right-most) dimension.  <code class="code"><span class="constructor">Genarray</span>.sub_right&nbsp;a&nbsp;ofs&nbsp;len</code>
     returns a big array with the same number of dimensions as <code class="code">a</code>,
     and the same dimensions as <code class="code">a</code>, except the last dimension,
     which corresponds to the interval <code class="code">[ofs&nbsp;...&nbsp;ofs&nbsp;+&nbsp;len&nbsp;-&nbsp;1]</code>
     of the last dimension of <code class="code">a</code>.  No copying of elements is
     involved: the sub-array and the original array share the same
     storage space.  In other terms, the element at coordinates
     <code class="code">[|i1;&nbsp;...;&nbsp;iN|]</code> of the sub-array is identical to the
     element at coordinates <code class="code">[|i1;&nbsp;...;&nbsp;iN+ofs|]</code> of the original
     array <code class="code">a</code>.</p>

<p><code class="code"><span class="constructor">Genarray</span>.sub_right</code> applies only to big arrays in Fortran layout.
     Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code">ofs</code> and <code class="code">len</code> do not designate
     a valid sub-array of <code class="code">a</code>, that is, if <code class="code">ofs&nbsp;&lt;&nbsp;1</code>, or <code class="code">len&nbsp;&lt;&nbsp;0</code>,
     or <code class="code">ofs&nbsp;+&nbsp;len&nbsp;&gt;&nbsp;<span class="constructor">Genarray</span>.nth_dim&nbsp;a&nbsp;(<span class="constructor">Genarray</span>.num_dims&nbsp;a&nbsp;-&nbsp;1)</code>.</p>
</div>
</div>

<pre><span id="VALslice_left"><span class="keyword">val</span> slice_left</span> : <code class="type">('a, 'b, <a href="Bigarray.html#TYPEc_layout">Bigarray.c_layout</a>) <a href="Bigarray.Genarray.html#TYPEt">t</a> -><br>       int array -> ('a, 'b, <a href="Bigarray.html#TYPEc_layout">Bigarray.c_layout</a>) <a href="Bigarray.Genarray.html#TYPEt">t</a></code></pre><div class="info ">
<div class="info-desc">
<p>Extract a sub-array of lower dimension from the given big array
     by fixing one or several of the first (left-most) coordinates.
     <code class="code"><span class="constructor">Genarray</span>.slice_left&nbsp;a&nbsp;[|i1;&nbsp;...&nbsp;;&nbsp;iM|]</code> returns the 'slice'
     of <code class="code">a</code> obtained by setting the first <code class="code"><span class="constructor">M</span></code> coordinates to
     <code class="code">i1</code>, ..., <code class="code">iM</code>.  If <code class="code">a</code> has <code class="code"><span class="constructor">N</span></code> dimensions, the slice has
     dimension <code class="code"><span class="constructor">N</span>&nbsp;-&nbsp;<span class="constructor">M</span></code>, and the element at coordinates
     <code class="code">[|j1;&nbsp;...;&nbsp;j(<span class="constructor">N</span>-<span class="constructor">M</span>)|]</code> in the slice is identical to the element
     at coordinates <code class="code">[|i1;&nbsp;...;&nbsp;iM;&nbsp;j1;&nbsp;...;&nbsp;j(<span class="constructor">N</span>-<span class="constructor">M</span>)|]</code> in the original
     array <code class="code">a</code>.  No copying of elements is involved: the slice and
     the original array share the same storage space.</p>

<p><code class="code"><span class="constructor">Genarray</span>.slice_left</code> applies only to big arrays in C layout.
     Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code"><span class="constructor">M</span>&nbsp;&gt;=&nbsp;<span class="constructor">N</span></code>, or if <code class="code">[|i1;&nbsp;...&nbsp;;&nbsp;iM|]</code>
     is outside the bounds of <code class="code">a</code>.</p>
</div>
</div>

<pre><span id="VALslice_right"><span class="keyword">val</span> slice_right</span> : <code class="type">('a, 'b, <a href="Bigarray.html#TYPEfortran_layout">Bigarray.fortran_layout</a>) <a href="Bigarray.Genarray.html#TYPEt">t</a> -><br>       int array -> ('a, 'b, <a href="Bigarray.html#TYPEfortran_layout">Bigarray.fortran_layout</a>) <a href="Bigarray.Genarray.html#TYPEt">t</a></code></pre><div class="info ">
<div class="info-desc">
<p>Extract a sub-array of lower dimension from the given big array
     by fixing one or several of the last (right-most) coordinates.
     <code class="code"><span class="constructor">Genarray</span>.slice_right&nbsp;a&nbsp;[|i1;&nbsp;...&nbsp;;&nbsp;iM|]</code> returns the 'slice'
     of <code class="code">a</code> obtained by setting the last <code class="code"><span class="constructor">M</span></code> coordinates to
     <code class="code">i1</code>, ..., <code class="code">iM</code>.  If <code class="code">a</code> has <code class="code"><span class="constructor">N</span></code> dimensions, the slice has
     dimension <code class="code"><span class="constructor">N</span>&nbsp;-&nbsp;<span class="constructor">M</span></code>, and the element at coordinates
     <code class="code">[|j1;&nbsp;...;&nbsp;j(<span class="constructor">N</span>-<span class="constructor">M</span>)|]</code> in the slice is identical to the element
     at coordinates <code class="code">[|j1;&nbsp;...;&nbsp;j(<span class="constructor">N</span>-<span class="constructor">M</span>);&nbsp;i1;&nbsp;...;&nbsp;iM|]</code> in the original
     array <code class="code">a</code>.  No copying of elements is involved: the slice and
     the original array share the same storage space.</p>

<p><code class="code"><span class="constructor">Genarray</span>.slice_right</code> applies only to big arrays in Fortran layout.
     Raise <code class="code"><span class="constructor">Invalid_argument</span></code> if <code class="code"><span class="constructor">M</span>&nbsp;&gt;=&nbsp;<span class="constructor">N</span></code>, or if <code class="code">[|i1;&nbsp;...&nbsp;;&nbsp;iM|]</code>
     is outside the bounds of <code class="code">a</code>.</p>
</div>
</div>

<pre><span id="VALblit"><span class="keyword">val</span> blit</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> ('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Copy all elements of a big array in another big array.
     <code class="code"><span class="constructor">Genarray</span>.blit&nbsp;src&nbsp;dst</code> copies all elements of <code class="code">src</code> into
     <code class="code">dst</code>.  Both arrays <code class="code">src</code> and <code class="code">dst</code> must have the same number of
     dimensions and equal dimensions.  Copying a sub-array of <code class="code">src</code>
     to a sub-array of <code class="code">dst</code> can be achieved by applying <code class="code"><span class="constructor">Genarray</span>.blit</code>
     to sub-array or slices of <code class="code">src</code> and <code class="code">dst</code>.</p>
</div>
</div>

<pre><span id="VALfill"><span class="keyword">val</span> fill</span> : <code class="type">('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a> -> 'a -> unit</code></pre><div class="info ">
<div class="info-desc">
<p>Set all elements of a big array to a given value.
     <code class="code"><span class="constructor">Genarray</span>.fill&nbsp;a&nbsp;v</code> stores the value <code class="code">v</code> in all elements of
     the big array <code class="code">a</code>.  Setting only some elements of <code class="code">a</code> to <code class="code">v</code>
     can be achieved by applying <code class="code"><span class="constructor">Genarray</span>.fill</code> to a sub-array
     or a slice of <code class="code">a</code>.</p>
</div>
</div>

<pre><span id="VALmap_file"><span class="keyword">val</span> map_file</span> : <code class="type"><a href="Unix.html#TYPEfile_descr">Unix.file_descr</a> -><br>       ?pos:int64 -><br>       ('a, 'b) <a href="Bigarray.html#TYPEkind">Bigarray.kind</a> -><br>       'c <a href="Bigarray.html#TYPElayout">Bigarray.layout</a> -> bool -> int array -> ('a, 'b, 'c) <a href="Bigarray.Genarray.html#TYPEt">t</a></code></pre></body></html>